'''
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License") you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http:#www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
'''


#import java.util.Calendar;

#import org.apache.jena.datatypes.DatatypeFormatException;
#import org.apache.jena.datatypes.RDFDatatype;
#import org.apache.jena.graph.Node;


'''
 * Convenience methods which extend the:@link Model interface.
 * <P>The:@link Model interface provides a set of primitive operations on
 * an RDF model.  This interface extends those methods with a
 * set of convenience methods.</P>
 * <p>This interface provides methods supporting typed literals.  This means
 * that methods are provided which will translate a built in type, or an
 * object to an RDF Literal.  This translation is done by invoking the
 * <CODE>toString()</CODE> method of the object, or its built in equivalent.
 * The reverse translation is also supported.  This is built in for built
 * in types.  Factory objects, provided by the application, are used
 * for application objects.</p>
 * <p>This interface provides methods for supporting enhanced resources.  An
 * enhanced resource is a resource to which the application has added
 * behaviour.  RDF containers are examples of enhanced resources built in
 * to this package.  Enhanced resources are supported by encapsulating a
 * resource created by an implementation in another class which adds
 * the extra behaviour.  Factory objects are used to construct such
 * enhanced resources.</p>
'''
from abc import ABC, abstractmethod

class ModelCon (ABC):

    '''
     * Return a Resource instance in this model.
     *
     * <p>Subsequent operations on the returned object may modify this model.</p>
     * <p>The resource is assumed to already exist in the model.  If it does not,
     * <CODE>createResource</CODE> should be used instead.</p>
     *
     * @param uri the URI of the resource
     * @param f   the factory object
     * @return a resource instance created by the factory provided
    '''
    #@Deprecated
    # param String uri, ResourceF f
    # result Resource
    @abstractmethod
    def getResource(self, uri, f):
        pass

    '''
     * Return a Property instance in this model.
     *
     * <p>Subsequent operations on the returned property may modify this model.</p>
     * <p>The property is assumed to already exist in the model.  If it does not,
     * <CODE>createProperty</CODE> should be used instead.</p>
     *
     * @param uri the URI of the property
     * @return a property object
    '''
    # param String uri
    # result Property
    @abstractmethod
    def getProperty(self, uri):
        pass

    '''
     * Return a Bag instance in this model.
     *
     * <p>Subsequent operations on the returned bag may modify this model.</p>
     * <p>The bag is assumed to already exist in the model.  If it does not,
     * <CODE>createBag</CODE> should be used instead.</p>
     *
     * @param uri the URI of the bag.
     * @return a bag instance
    '''
    # param String uri
    # result Bag
    @abstractmethod
    def getBag(self, uri):
        pass

    '''
     * Return a bag instance based on a given resource.
     *
     * <p> This method enables an application to treat any resource as a bag.
     * It is in effect an unsafe downcast.</p>
     *
     * <p>Subsequent operations on the returned bag may modify this model.</p>
     * <p>The bag is assumed to already exist in the model.  If it does not,
     * <CODE>createBag</CODE> should be used instead.</p>
     *
     * @param r an untyped Resource instance
     * @return a bag instance
    '''
    # param Resource r
    # result Bag
    # @abstractmethod
    # def getBag(self, r):
    #     pass

    '''
     * Return an Alt instance in this model.
     *
     * <p>Subsequent operations on the returned object may modify this model.</p>
     * <p>The alt is assumed to already exist in the model.  If it does not,
     * <CODE>createAlt</CODE> should be used instead.</p>
     *
     * @param uri the URI of the alt
     * @return an alt instance
    '''
    # param String uri
    # result Alt
    @abstractmethod
    def getAlt(self, uri):
        pass

    '''
     * Return an Alt instance based on a given resource.
     *
     * <p> This method enables an application to treat any resource as an Alt.
     * It is in effect an unsafe downcast.</p>
     *
     * <p>Subsequent operations on the returned Alt may modify this model.</p>
     * <p>The Alt is assumed to already exist in the model.  If it does not,
     * <CODE>createAlt</CODE> should be used instead.</p>
     *
     * @param r an untyped Resource instance
     * @return an Alt instance
    '''
    # param Resource r
    # result Alt
    # @abstractmethod
    # def getAlt(self, r):
    #     pass

    '''
     * Return a Seq instance in this model.
     *
     * <p>Subsequent operations on the returned sequence may modify this model.</p>
     * <p>The seq is assumed to already exist in the model.  If it does not,
     * <CODE>createSeq</CODE> should be used instead.</p>
     *
     * @param uri the URI of the seq
     * @return a seq instance
    '''
    # param String uri
    # result Seq
    @abstractmethod
    def getSeq(self, uri):
        pass

    '''
     * Return a Seq instance based on a given resource.
     *
     * <p> This method enables an application to treat any resource as a Seq.
     * It is in effect an unsafe downcast.</p>
     *
     * <p>Subsequent operations on the returned Seq may modify this model.</p>
     * <p>The Seq is assumed to already exist in the model.  If it does not,
     * <CODE>createSeq</CODE> should be used instead.</p>
     *
     * @param r an untyped Resource instance
     * @return an Seq instance
    '''
    # param Resource r
    # result Seq
    # @abstractmethod
    # def getSeq(self, r):
    #     pass

    '''
     * Return a RDF List instance in this model.
     *
     * <p>Subsequent operations on the returned list may modify this model.</p>
     * <p>The list is assumed to already exist in the model.  If it does not,
     * <CODE>createList</CODE> should be used instead.</p>
     *
     * @param uri the URI of the list
     * @return a list instance
    '''
    # param String uri
    # result RDFList
    @abstractmethod
    def getList(self, uri):
        pass

    '''
     * Return a RDF List based on a given resource.
     *
     * <p> This method enables an application to treat any resource as a list.
     * It is in effect an unsafe downcast.</p>
     *
     * <p>Subsequent operations on the returned list may modify this model.</p>
     * <p>The list is assumed to already exist in the model.  If it does not,
     * <CODE>createList</CODE> should be used instead.</p>
     *
     * @param r the resource of the list
     * @return a list instance
    '''
    # param Resource r
    # result RDFList
    # @abstractmethod
    # def getList(self, r):
    #     pass

    '''
     * Create a new anonymous resource with a given type.
     *
     * <p> Subsequent operations on the returned resource may modify this model.
     * </p>
     * <p> The resource is created and an rdf:type property added to the model
     * to specify its type. </p>
     *
     * @param type the type of the resource to be created.
     * @return a new anonymous resource linked to this model.
    '''
    # param Resource type
    # result Resource
    @abstractmethod
    def createResource(self, type):
        pass

    '''
     * Create or find an RDFNode
     * (a:@link Resource or a:@link Literal)
     * from a graph Node. This is provided for users and
     * developers operating at the API/SPI interface, where Resources are
     * constructed from Nodes. Providing this method allows each Model
     * the opportunity to cache node-to-resource maps if it requires.
     *
     * @param n the graph.Node on which to base the Model.RDFNode
     * @return a suitable RDFNode
    '''
    # param Node n
    # result RDFNode
    @abstractmethod
    def getRDFNode(self, n):
        pass

    '''
     * Create a new resource with a given type.
     *
     * <p> Subsequent operations on the returned resource may modify this model.
     * </p>
     * <p> The resource is created and an rdf:type property added to the model
     * to specify its type. </p>
     *
     * @param type the type of the resource to be created.
     * @param uri  The URI of the new resource.
     * @return a new resource linked to this model.
    '''
    # param String uri, Resource type
    # result Resource
    # @abstractmethod
    # def createResource(self, uri, type):
    #     pass

    '''
     * Create a new anonymous resource using the supplied factory.
     *
     * <p> Subsequent operations on the returned resource may modify this model.
     * </p>
     *
     * @param f A factory object to create the returned object.
     *          .
     * @return a new anonymous resource linked to this model.
    '''
    #@Deprecated
    # param ResourceF f
    # result Resource
    # @abstractmethod
    # def createResource(self, f):
    #     pass

    '''
     * Create a new resource using the supplied factory.
     *
     * <p> Subsequent operations on the returned resource may modify this model.
     * </p>
     *
     * @param uri the URI of the resource
     * @param f   A factory to create the returned object.
     *            .
     * @return a new resource linked to this model.
    '''
    #@Deprecated
    # param String uri, ResourceF f
    # result Resource
    # @abstractmethod
    # def createResource(self, uri, f):
    #     pass

    '''
     * Create a property.
     *
     * <p> Subsequent operations on the returned property may modify this model.
     * </p>
     *
     * @param uri the URI of the property
     * @return a property instance
    '''
    # param String uri
    # result Property
    @abstractmethod
    def createProperty(self, uri):
        pass

    '''
     * create a literal from a String value.
     *
     * @param v the value of the literal
     * @return a new literal representing the value v
    '''
    # param String v
    # result Literal
    @abstractmethod
    def createLiteral(self, v):
        pass

    '''
     * create a type literal from a boolean value.
     *
     * <p> The value is converted to a string using its <CODE>toString</CODE>
     * method. </p>
     *
     * @param v the value of the literal
     * @return a new literal representing the value v
    '''
    # param boolean v
    # result Literal
    @abstractmethod
    def createTypedLiteral(self, v):
        pass

    '''
     * create a typed literal from an integer value.
     *
     * @param v the value of the literal
     * @return a new literal representing the value v
    '''
    # param int v
    # result Literal
    # @abstractmethod
    # def createTypedLiteral(self, v):
    #     pass

    '''
     * create a typed literal from an integer value.
     *
     * @param v the value of the literal
     * @return a new literal representing the value v
    '''
    # param long v
    # result Literal
    # @abstractmethod
    # def createTypedLiteral(self, v):
    #     pass

    '''
     * Create a typed literal of type xsd:dateTime from a Calendar object.
    '''
    # param Calendar d
    # result Literal
    # @abstractmethod
    # def createTypedLiteral(self, d):
    #     pass

    '''
     * create a typed literal from a char value.
     *
     * @param v the value of the literal
     * @return a new literal representing the value v
    '''
    # param char v
    # result Literal
    # @abstractmethod
    # def createTypedLiteral(self, v):
    #     pass

    '''
     * create a typed literal from a float value.
     *
     * @param v the value of the literal
     * @return a new literal representing the value v
    '''
    # param float v
    # result Literal
    # @abstractmethod
    # def createTypedLiteral(self, v):
    #     pass

    '''
     * create a typed literal from a double value.
     *
     * @param v the value of the literal
     * @return a new literal representing the value v
    '''
    # param double v
    # result Literal
    # @abstractmethod
    # def createTypedLiteral(self, v):
    #     pass

    '''
     * create a typed literal from a String value.
     *
     * @param v the value of the literal
     * @return a new literal representing the value v
    '''
    # param String v
    # result Literal
    # @abstractmethod
    # def createTypedLiteral(self, v):
    #     pass

    '''
     * create a literal from an Object.
     *
     * @param v the value of the literal.
     * @return a new literal representing the value v
    '''
    # param Object v
    # result Literal
    # @abstractmethod
    # def createTypedLiteral(self, v):
    #     pass

    '''
     * Build a typed literal from its lexical form. The
     * lexical form will be parsed now and the value stored. If
     * the form is not legal this will throw an exception.
     * <p>
     * Note that in preview releases of Jena2 it was also possible to specify
     * a language type. Changes to the RDF specification mean that this is no longer
     * legal except for plain literals. To create a plain literal with a language tag
     * use:@link Model#createLiteral(String, String) createLiteral.
     * </p>
     *
     * @param lex     the lexical form of the literal
     * @param typeURI the uri of the type of the literal, null for old style "plain" literals
     * @throws DatatypeFormatException if lex is not a legal form of dtype
    '''
    # param String lex, String typeURI
    # result Literal
    # @abstractmethod
    # def createTypedLiteral(self, lex, typeURI):
    #     pass

    '''
     * Build a typed literal from its value form.
     * <p>
     * Note that in preview releases of Jena2 it was also possible to specify
     * a language type. Changes to the RDF specification mean that this is no longer
     * legal except for plain literals. To create a plain literal with a language tag
     * use:@link Model#createLiteral(String, String) createLiteral.
     * </p>
     *
     * @param value   the value of the literal
     * @param typeURI the URI of the type of the literal, null for old style "plain" literals
    '''
    # param Object value, String typeURI
    # result Literal
    # @abstractmethod
    # def createTypedLiteral(self, value, typeURI):
    #     pass

    '''
     * Answer a new Statement object (s, p, o') where o' is the typed literal
     * corresponding to o using createTypedLiteral.
    '''
    # param Resource s, Property p, boolean o
    # result Statement
    # @abstractmethod
    # def createLiteralStatement(self, s, p, o):
    #     pass

    '''
     * Answer a new Statement object (s, p, o') where o' is the typed literal
     * corresponding to o using createTypedLiteral.
    '''
    # param Resource s, Property p, float o
    # result Statement
    # @abstractmethod
    # def createLiteralStatement(self, s, p, o):
    #     pass

    '''
     * Answer a new Statement object (s, p, o') where o' is the typed literal
     * corresponding to o using createTypedLiteral.
    '''
    # param Resource s, Property p, double o
    # result Statement
    # @abstractmethod
    # def createLiteralStatement(self, s, p, o):
    #     pass

    '''
     * Answer a new Statement object (s, p, o') where o' is the typed literal
     * corresponding to o using createTypedLiteral.
    '''
    # param Resource s, Property p, long o
    # result Statement
    # @abstractmethod
    # def createLiteralStatement(self, s, p, o):
    #     pass

    '''
     * Answer a new Statement object (s, p, o') where o' is the typed literal
     * corresponding to o using createTypedLiteral.
    '''
    # param Resource s, Property p, int o
    # result Statement
    # @abstractmethod
    # def createLiteralStatement(self, s, p, o):
    #     pass

    '''
     * Answer a new Statement object (s, p, o') where o' is the typed literal
     * corresponding to o using createTypedLiteral.
    '''
    # param Resource s, Property p, char o
    # result Statement
    # @abstractmethod
    # def createLiteralStatement(self, s, p, o):
    #     pass

    '''
     * Answer a new Statement object (s, p, o') where o' is the typed literal
     * corresponding to o using createTypedLiteral.
    '''
    # param Resource s, Property p, Object o
    # result Statement
    # @abstractmethod
    # def createLiteralStatement(self, s, p, o):
    #     pass

    '''
     * Create a Statement instance.
     *
     * <p>Subsequent operations on the statement or any of its parts may
     * modify this model.</p>
     * <p>Creating a statement does not add it to the set of statements in the
     * model. </p>
     * <p>The Object o will be converted to a Literal.</P>
     *
     * @param s the subject of the statement
     * @param p the predicate of the statement
     * @param o is the value to be the object of the statement
     * @return the new statement
    '''
    # param Resource s, Property p, String o
    # result Statement
    @abstractmethod
    def createStatement(self, s, p, o):
        pass

    '''
     * Create a Statement instance.
     *
     * <p>Subsequent operations on the statement or any of its parts may
     * modify this model.</p>
     * <p>Creating a statement does not add it to the set of statements in the
     * model. </p>
     * <p>The Object o will be converted to a Literal.</P>
     *
     * @param s the subject of the statement
     * @param p the predicate of the statement
     * @param o is the value to be the object of the statement
     * @param l the language associated with the object
     * @return the new statement
    '''
    # param Resource s, Property p, String o, String l
    # result Statement
    # @abstractmethod
    # def createStatement(self, s, p, o, l):
    #     pass

    '''
     * Create a Statement instance.
     *
     * <p>Subsequent operations on the statement or any of its parts may
     * modify this model.</p>
     * <p>Creating a statement does not add it to the set of statements in the
     * model. </p>
     * <p>The Object o will be converted to a Literal.</P>
     *
     * @param s          the subject of the statement
     * @param p          the predicate of the statement
     * @param o          is the value to be the object of the statement
     * @param wellFormed true if the string is well formed XML
     * @return the new statement
    '''
    # public Statement createStatement(Resource s, Property p, String o,
    #                                  boolean wellFormed)

    '''
     * Create a Statement instance.
     *
     * <p>Subsequent operations on the statement or any of its parts may
     * modify this model.</p>
     * <p>Creating a statement does not add it to the set of statements in the
     * model. </p>
     * <p>The Object o will be converted to a Literal.</P>
     *
     * @param s          the subject of the statement
     * @param p          the predicate of the statement
     * @param o          is the value to be the object of the statement
     * @param l          the language associated with the object
     * @param wellFormed true of the string is well formed XML
     * @return the new statement
     * @deprecated To be removed. Argument 'wellFormed' is ignored
    '''
    #@Deprecated
    # param Resource s, Property p, String o, String l, boolean wellFormed
    # result Statement
    # @abstractmethod
    # def createStatement(self, s, p, o, l, wellFormed):
    #     pass


    '''
     * Create a new anonymous bag.
     *
     * <p>Subsequent operations on the bag or any of its parts may
     * modify this model.</p>
     * <p>A statement defining the type of the new bag is added to this model.
     * </p>
     *
     * @return a new anonymous bag.
    '''
    # param 
    # result Bag
    @abstractmethod
    def createBag(self):
        pass

    '''
     * Create a new bag.
     *
     * <p>Subsequent operations on the bag or any of its parts may
     * modify this model.</p>
     * <p>A statement defining the type of the new bag is added to this model.
     * </p>
     *
     * @param uri The URI of the new Bag.
     * @return a new bag.
    '''
    # param String uri
    # result Bag
    # @abstractmethod
    # def createBag(self, uri):
    #     pass

    '''
     * Create a new anonymous alt.
     *
     * <p>Subsequent operations on the alt or any of its parts may
     * modify this model.</p>
     * <p>A statement defining the type of the new alt is added to this model.
     * </p>
     *
     * @return a new anonymous alt.
    '''
    # param 
    # result Alt
    @abstractmethod
    def createAlt(self):
        pass

    '''
     * Create a new alt.
     *
     * <p>Subsequent operations on the alt or any of its parts may
     * modify this model.</p>
     * <p>A statement defining the type of the new alt is added to this model.
     * </p>
     *
     * @param uri The URI of the new alt.
     * @return a new alt.
    '''
    # param String uri
    # result Alt
    # @abstractmethod
    # def createAlt(self, uri):
    #     pass

    '''
     * Create a new anonymous seq.
     *
     * <p>Subsequent operations on the seq or any of its parts may
     * modify this model.</p>
     * <p>A statement defining the type of the new seq is added to this model.
     * </p>
     *
     * @return a new anonymous seq.
    '''
    # param 
    # result Seq
    @abstractmethod
    def createSeq(self):
        pass

    '''
     * Create a new seq.
     *
     * <p>Subsequent operations on the seq or any of its parts may
     * modify this model.</p>
     * <p>A statement defining the type of the new seq is added to this model.
     * </p>
     *
     * @param uri The URI of the new seq.
     * @return a new seq.
    '''
    # param String uri
    # result Seq
    # @abstractmethod
    # def createSeq(self, uri):
    #     pass

    '''
     * add a statement to this model.
     *
     * @param s the subject of the statement to add
     * @param p the predicate of the statement to add
     * @param o the object of the statement to add
     * @return this model
    '''
    # param Resource s, Property p, RDFNode o
    # result Model
    @abstractmethod
    def add(self, s, p, o):
        pass

    '''
     * Add the statement (s, p, createTypedLiteral( o )) to this model and
     * answer this model.
    '''
    # param Resource s, Property p, boolean o
    # result Model
    @abstractmethod
    def addLiteral(self, s, p, o):
        pass

    '''
     * Add the statement (s, p, createTypedLiteral( o )) to this model and
     * answer this model.
    '''
    # param Resource s, Property p, long o
    # result Model
    # @abstractmethod
    # def addLiteral(self, s, p, o):
    #     pass

    '''
     * Add the statement (s, p, createTypedLiteral( o )) to this model and
     * answer this model.
    '''
    # param Resource s, Property p, int o
    # result Model
    # @abstractmethod
    # def addLiteral(self, s, p, o):
    #     pass

    '''
     * Add the statement (s, p, createTypedLiteral( o )) to this model and
     * answer this model.
    '''
    # param Resource s, Property p, char o
    # result Model
    # @abstractmethod
    # def addLiteral(self, s, p, o):
    #     pass

    '''
     * Add the statement (s, p, o') to the model, where o' is the typed
     * literal corresponding to o. Answer this model.
    '''
    # param Resource s, Property p, float o
    # result Model
    # @abstractmethod
    # def addLiteral(self, s, p, o):
    #     pass

    '''
     * Add the statement (s, p, o') to the model, where o' is the typed
     * literal corresponding to o. Answer this model.
    '''
    # param Resource s, Property p, double o
    # result Model
    # @abstractmethod
    # def addLiteral(self, s, p, o):
    #     pass

    '''
     * add a statement to this model.
     * Applications should use typed literals whereever possible.
     *
     * @param s the subject of the statement to add
     * @param p the predicate of the statement to add
     * @param o the object of the statement to add
     * @return this model
     * @deprecated Freshly (should have been done a while ago)
    '''
    #@Deprecated
    # param Resource s, Property p, Object o
    # result Model
    # @abstractmethod
    # def addLiteral(self, s, p, o):
    #     pass

    '''
     * add a statement to this model.
     *
     * @param s the subject of the statement to add
     * @param p the predicate of the statement to add
     * @param o the object of the statement to add
     * @return this model
    '''
    # param Resource s, Property p, Literal o
    # result Model
    # @abstractmethod
    # def addLiteral(self, s, p, o):
    #     pass

    '''
     * add a statement to this model.
     *
     * @param s the subject of the statement to add
     * @param p the predicate of the statement to add
     * @param o the object of the statement to add
     * @return this model
    '''
    # param Resource s, Property p, String o
    # result Model
    # @abstractmethod
    # def add(self, s, p, o):
    #     pass

    '''
     * add a statement to this model.
     *
     * @param s        the subject of the statement to add
     * @param p        the predicate of the statement to add
     * @param lex      the lexcial form of the literal
     * @param datatype the datatype of the literal
     * @return this model
    '''
    # param Resource s, Property p, String lex, RDFDatatype datatype
    # result Model
    # @abstractmethod
    # def add(self, s, p, lex, datatype):
    #     pass

    '''
     * add a statement to this model.
     *
     * @param s          the subject of the statement to add
     * @param p          the predicate of the statement to add
     * @param o          the object of the statement to add
     * @param wellFormed true if o is well formed XML
     * @return this model
     * @deprecated To be removed. Argument 'wellFormed' is ignored
    '''
    #@Deprecated
    # param Resource s, Property p, String o, boolean wellFormed
    # result Model
    # @abstractmethod
    # def add(self, s, p, o, wellFormed):
    #     pass

    '''
     * add a statement to this model.
     *
     * @param s the subject of the statement to add
     * @param p the predicate of the statement to add
     * @param o the object of the statement to add
     * @param l the language associated with the object
     * @return this model
    '''
    # param Resource s, Property p, String o, String l
    # result Model
    # @abstractmethod
    # def add(self, s, p, o, l):
    #     pass

    '''
     * remove the statement <code>(s, p, o)</code> from this model and
     * answer this model. None of <code>s, p, o</code> are permitted to
     * be <code>null</code>: for wildcard removal, see <code>removeAll</code>.
    '''
    # param Resource s, Property p, RDFNode o
    # result Model
    @abstractmethod
    def remove(self, s, p, o):
        pass

    '''
     * Remove all the Statements returned by an iterator.
     *
     * @param ite the iterator which returns the statements to be removed.
     * @return this model
    '''
    # param StmtIterator ite
    # result Model
    # @abstractmethod
    # def remove(self, ite):
    #     pass

    '''
     * Remove all the Statements in a given model, including reified statements
     *
     * @param m the model containing the statements to be removed.
     * @return this model
    '''
    # param Model m
    # result Model
    # @abstractmethod
    # def remove(self, m):
    #     pass

    '''
     * Answer a statement iterator that will iterate over all the statements
     * (S, P, O) in this model where S matches <code>subject</code>, P
     * matches <code>predicate</code>, and O matches the typed literal
     * corresponding to <code>object</code>.
    '''
    # param Resource subject, Property predicate, boolean object
    # result StmtIterator
    # @abstractmethod
    # def listLiteralStatements(self, subject, predicate, object):
    #     pass

    '''
     * Answer a statement iterator that will iterate over all the statements
     * (S, P, O) in this model where S matches <code>subject</code>, P
     * matches <code>predicate</code>, and O matches the typed literal
     * corresponding to <code>object</code>.
    '''
    # param Resource subject, Property predicate, char object
    # result StmtIterator
    # @abstractmethod
    # def listLiteralStatements(self, subject, predicate, object):
    #     pass

    '''
     * Answer a statement iterator that will iterate over all the statements
     * (S, P, O) in this model where S matches <code>subject</code>, P
     * matches <code>predicate</code>, and O matches the typed literal
     * corresponding to <code>object</code>.
    '''
    # param Resource subject, Property predicate, long object
    # result StmtIterator
    # @abstractmethod
    # def listLiteralStatements(self, subject, predicate, object):
    #     pass

    '''
     * Answer a statement iterator that will iterate over all the statements
     * (S, P, O) in this model where S matches <code>subject</code>, P
     * matches <code>predicate</code>, and O matches the typed literal
     * corresponding to <code>object</code>.
    '''
    # param Resource subject, Property predicate, int object
    # result StmtIterator
    # @abstractmethod
    # def listLiteralStatements(self, subject, predicate, object):
    #     pass

    '''
     * Answer a statement iterator that will iterate over all the statements
     * (S, P, O) in this model where S matches <code>subject</code>, P
     * matches <code>predicate</code>, and O matches the typed literal
     * corresponding to <code>object</code>.
    '''
    # param Resource subject, Property predicate, float object
    # result StmtIterator
    # @abstractmethod
    # def listLiteralStatements(self, subject, predicate, object):
    #     pass

    '''
     * Answer a statement iterator that will iterate over all the statements
     * (S, P, O) in this model where S matches <code>subject</code>, P
     * matches <code>predicate</code>, and O matches the typed literal
     * corresponding to <code>object</code>.
    '''
    # param Resource subject, Property predicate, double object
    # result StmtIterator
    # @abstractmethod
    # def listLiteralStatements(self, subject, predicate, object):
    #     pass

    '''
     * Find all the statements matching a pattern.
     * <p>Return an iterator over all the statements in a model
     * that match a pattern.  The statements selected are those
     * whose subject matches the <code>subject</code> argument,
     * whose predicate matches the <code>predicate</code> argument
     * and whose object matchesthe <code>object</code> argument.</p>
     *
     * @param subject   The subject sought
     * @param predicate The predicate sought
     * @param object    The value sought
     * @return an iterator over the subjects
    '''
    # param Resource subject, Property predicate, String object
    # result StmtIterator
    @abstractmethod
    def listStatements(self, subject, predicate, object):
        pass

    '''
     * Find all the statements matching a pattern.
     * <p>Return an iterator over all the statements in a model
     * that match a pattern.  The statements selected are those
     * whose subject matches the <code>subject</code> argument,
     * whose predicate matches the <code>predicate</code> argument
     * and whose object matchesthe <code>object</code> argument.
     * If an argument is <code>null</code> it matches anything.</p>
     *
     * @param subject   The subject sought
     * @param predicate The predicate sought
     * @param object    The value sought
     * @param lang      The lang code ofthe string.
     * @return an iterator over the subjects
    '''
    # StmtIterator listStatements(Resource subject,
    #                             Property predicate,
    #                             String object,
    #                             String lang)
    

    '''
     * Answer an iterator [without duplicates] over all the resources in this
     * model which have value o' for property p, where o' is the typed literal
     * corresponding to o.
    '''
    # param Property p, boolean o
    # result ResIterator
    @abstractmethod
    def listResourcesWithProperty(self, p, o):
        pass

    '''
     * Answer an iterator [without duplicates] over all the resources in this
     * model which have value o' for property p, where o' is the typed literal
     * corresponding to o.
    '''
    # param Property p, long o
    # result ResIterator
    # @abstractmethod
    # def listResourcesWithProperty(self, p, o):
    #     pass

    '''
     * Answer an iterator [without duplicates] over all the resources in this
     * model which have value o' for property p, where o' is the typed literal
     * corresponding to o.
    '''
    # param Property p, char o
    # result ResIterator
    # @abstractmethod
    # def listResourcesWithProperty(self, p, o):
    #     pass

    '''
     * Answer an iterator [without duplicates] over all the resources in this
     * model which have value o' for property p, where o' is the typed literal
     * corresponding to o.
    '''
    # param Property p, float o
    # result ResIterator
    # @abstractmethod
    # def listResourcesWithProperty(self, p, o):
    #     pass

    '''
     * Answer an iterator [without duplicates] over all the resources in this
     * model which have value o' for property p, where o' is the typed literal
     * corresponding to o.
    '''
    # param Property p, double o
    # result ResIterator
    # @abstractmethod
    # def listResourcesWithProperty(self, p, o):
    #     pass

    '''
     * Answer an iterator [without duplicates] over all the resources in this
     * model which have value o' for property p, where o' is the typed literal
     * corresponding to o.
    '''
    # param Property p, Object o
    # result ResIterator
    # @abstractmethod
    # def listResourcesWithProperty(self, p, o):
    #     pass

    '''
     * lists all subjects with a given property and property value.
     *
     * @param p The predicate sought.
     * @param o The property value sought.
     * @return an iterator over the set of subjects
    '''
    # param Property p, String o
    # result ResIterator
    @abstractmethod
    def listSubjectsWithProperty(self, p, o):
        pass

    '''
     * lists all subjects with a given property and property value.
     *
     * @param p The predicate sought.
     * @param o The property value sought.
     * @param l the language associated with the object
     * @return an iterator over the set of subjects
    '''
    # param Property p, String o, String l
    # result ResIterator
    # @abstractmethod
    # def listSubjectsWithProperty(self, p, o, l):
    #     pass

    '''
     * Answer true iff this model contains the statement (s, p, o') where
     * o' is the typed literal corresponding to the value o.
    '''
    # param Resource s, Property p, boolean o
    # result boolean
    # @abstractmethod
    # def containsLiteral(self, s, p, o):
    #     pass

    '''
     * Answer true iff this model contains the statement (s, p, o') where
     * o' is the typed literal corresponding to the value o.
    '''
    # param Resource s, Property p, long o
    # result boolean
    # @abstractmethod
    # def containsLiteral(self, s, p, o):
    #     pass

    '''
     * Answer true iff this model contains the statement (s, p, o') where
     * o' is the typed literal corresponding to the value o.
    '''
    # param Resource s, Property p, int o
    # result boolean
    # @abstractmethod
    # def containsLiteral(self, s, p, o):
    #     pass

    '''
     * Answer true iff this model contains the statement (s, p, o') where
     * o' is the typed literal corresponding to the value o.
    '''
    # param Resource s, Property p, char o
    # result boolean
    # @abstractmethod
    # def containsLiteral(self, s, p, o):
    #     pass

    '''
     * Answer true iff this model contains (s, p, o') where o' is the typed
     * literal corresponding to o.
    '''
    # param Resource s, Property p, float o
    # result boolean
    # @abstractmethod
    # def containsLiteral(self, s, p, o):
    #     pass

    '''
     * Answer true iff this model contains the statement (s, p, o') where
     * o' is the typed literal corresponding to the value o.
    '''
    # param Resource s, Property p, double o
    # result boolean
    # @abstractmethod
    # def containsLiteral(self, s, p, o):
    #     pass

    '''
     * Answer true iff this model contains the statement (s, p, o') where
     * o' is the typed literal corresponding to the value o.
    '''
    # param Resource s, Property p, Object o
    # result boolean
    # @abstractmethod
    # def containsLiteral(self, s, p, o):
    #     pass

    '''
     * Determine if a statement is present in this model.
     *
     * @param s The subject of the statment tested.
     * @param p The predicate of the statement tested.
     * @param o The object of the statement tested.
     * @return true if the statement with subject s, property p and object o
     * is in the model, false otherwise
    '''
    # param Resource s, Property p, String o
    # result boolean
    @abstractmethod
    def contains(self, s, p, o):
        pass

    '''
     * Determine if a statement is present in this model.
     *
     * @param s The subject of the statment tested.
     * @param p The predicate of the statement tested.
     * @param o The object of the statement tested.
     * @param l the language associated with the object
     * @return true if the statement with subject s, property p and object o
     * is in the model, false otherwise
    '''
    # param Resource s, Property p, String o, String l
    # result boolean
    # @abstractmethod
    # def contains(self, s, p, o, l):
    #     pass

